import java.sql.SQLOutput;

public class HelloWorld {
    //m main psvm 出现提示后 回车即可
    public static void main1(String[] args) {
        //sout 出现提示后 回车即可
        System.out.println("hello world");
    }
    public static void main2(String[] args) {
        //数据类型 变量 = 赋值   变量可以在运行的过程中修改的量
        int a = 10;
        final int b= 10;//final修饰的b叫做常量
    }

    public static void main3(String[] args) {
        /*
        1. a是整型变量 此时a占用4个字节【和操作系统是多少位没有关系】
        */
        int a = 10;
        System.out.println(a);
        //int 变量所能表示的范围
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }

    public static void main4(String[] args) {
        //8个字节
        //long a = 10;
        //long a = 10l
        long a = 10L;
        System.out.println(a);
        //long 变量所能表示的范围
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }

    public static void main5(String[] args) {
        //2各字节 19  16bit
        short sh = 10;
        System.out.println(sh);
        //short型 变量所能表示的范围
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }

    public static void main6(String[] args) {
        //1个字节  8个比特位
        byte a = 10;
        System.out.println(a);
        //byte型 变量所能表示的范围
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
    }

    public static void main7(String[] args) {
        //8个字节  64个比特位
        double d = 12.5;
        System.out.println(d);
        //double型变量所能表示的范围
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);

    }

    public static void main8(String[] args) {
/*        int a = 1;
        int b = 2;
        System.out.println(a/b);
        double c = 1.0;
        double d = 2.0;
        System.out.println(c/d);*/
        double num = 1.1;
        System.out.println(num*num);
    }

    public static void main9(String[] args) {
        float f = 12.5f;
        System.out.println(f);
        //float型变量所能表示的范围
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
    }

    public static void main10(String[] args) {
        //字符类型 是2个字节
        char ch = 'a';
        System.out.println(ch);
        char ch2 = '美';
        System.out.println(ch2);
    }

    public static void main11(String[] args) {
        boolean flg = true;
        System.out.println(flg);
    }

    public static void main12(String[] args) {
        int a = 10;
        long b = 20L;
        a = (int)b;//强制类型转换，不一定安全，有风险
        System.out.println(a);
        System.out.println(b);
    }

    public static void main13(String[] args) {
        System.Out.println(1024); // 整型默认情况下是int
        System.Out.println(3.14); // 浮点型默认情况下是double
        int a = 100;
        long b = 10L;
        b = a; // a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
        a = b; // 编译报错，long的范围比int范围大，会有数据丢失，不安全
        float f = 3.14F;
        double d = 5.12;
        d = f; // 编译器会将f转换为double，然后进行赋值
        f = d; // double表示数据范围大，直接将float交给double会有数据丢失，不安全
        byte b1 = 100; // 编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        byte b2 = 257; // 编译失败，257超过了byte的数据范围，有数据丢失

    }

    public static void main14(String[] args) {
        int a = 10;
        long b = 100L;
        b = a; // int-->long，数据范围由小到大，隐式转换
        a = (int)b; // long-->int, 数据范围由大到小，需要强转，否则编译失败
        float f = 3.14F;
        double d = 5.12;
        d = f; // float-->double，数据范围由小到大，隐式转换
        f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
        a = d; // 报错，类型不兼容
        a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃
        byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错
        boolean flag = true;
        a = flag; // 编译失败：类型不兼容
        flag = a; // 编译失败：类型不兼容
    }

    public static void main15(String[] args) {
        int a = 10;
        long b = 20;
        int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long
    }

    public static void main(String[] args) {
/*        byte a = 10;
        byte b = 20;
        byte c = a + b;
        System.out.println(c);*/

        byte a = 10;
        byte b = 20;
        byte c = (byte)(a + b);
        System.out.println(c);

    }
}

